Object oriented program languages such as Java (TM) are increasingly popular in more and more devices on account of portability of programs across platforms, operating systems and devices. This means that a program developed for one device is more readily used on another device of different characteristics, for example different operating systems or different microprocessors.
This popularity of object oriented programs is extending into devices that are significantly smaller in terms of memory size and processing power than traditional personal computers and other platforms on which such languages have been in widespread use. Problems have emerged in attempting to use object orienting languages such as Java (TM) on very small platforms for a number of reasons. An example of a problem lies in the need to support a complete set of object classes, where an object is a self-contained computer program which interacts with other programs in a defined manner, and where a class is a generic template for a set of objects with similar features. A problem is that in order to maintain the portability of programs across different platforms, uniformity needs to be present in the classes that any given application expects to be able to invoke. For example, pJava (TM) has a very large set of class libraries and efforts are in place to define a smaller language to be termed "eJava" (TM) using only a subset of the complete set of class libraries.
An example of a class is a telephony class that is invoked through a Java (TM) telephony API (JTAPI). An instance of such a class could be termed a "JTAPI implementation".
JTAPI is a portable, object oriented application programming interface for JAVA (TM)-based computer-telephony applications described at the following universal resource locator on the worldwide web: www.javasoft.com/products/JTAPI/index.html. The JAVA (TM) Telephony API supports both first- and third-party telephony application domains. The API is designed to make programming simple applications easy, while providing those features necessary for advanced telephony applications. JTAPI is a set of APIs. There is a "core" API providing a basic call model and rudimentary telephony features, such as placing telephone calls and answering telephone calls. The core API is surrounded by standard extension APIs providing functionality for specific telephony domains such as call centers and media stream access. Applications written using JTAPI are portable across various computer platforms and telephone systems. Version 1.2 of JTAPI was released to the public in December 1997.
An example of use of JTAPI is in a network configuration where the JTAPI application or JAVA (TM) applet runs on a remote station, such as a network computer with only a display, keyboard, processor and some memory. This computer accesses network resources, making use of a centralized server that manages telephony resources. JTAPI communicates with this server via a remote communication mechanism, such as the remote method invocation (RMI) of Java (TM) or a telephony protocol. The JAVA (TM) telephony API is composed of a set of JAVA (TM) language packages. Each package provides a piece of functionality for a certain aspect of computer-telephony applications.
Implementations of telephony servers choose the packages they support, depending on the capabilities of there underlying platform hardware. Applications may query for the packages supported by the implementation they are currently using. Additionally, application developers may concern themselves with only the supported packages that applications need to accomplish a task. For example, a call package permits applet designers to add telephone capabilities to a web page, while a number of standard extension packages extend the JTAPI core package. These extension packages bring additional telephony functionality to the API, such as: all control, call center, media, phone, private data and capabilities packages.
It would be desirable to use a standard telephony API such as JTAPI as a telephony API for a radio telephone or other radio communication device.
A number of problems lie in the way of using JTAPI as a telephony API for a wireless communication device, and in particular as a telephony API for a Global System for Mobile (GSM) radio telephone. In general JTAPI still suffers from the burden of having over 63 event classes with a total class file size of approximately 130 k bytes. This represents a substantial memory allocation for a relatively minor element of an overall program for a radio telephone. There is a need to reduce the memory requirement for programs that are JTAPI compatible.
In the context of a GSM communication device, there are GSM functions that cannot be easily accessed using existing JTAPI syntax and method signatures. Moreover, there is a need to support a dual-mode call (which is a term used in GSM for a voice and fax call or a voice and data call) and the concept of a dual-mode call is unknown in wireline telephony and in JTAPI. Simply adding to JTAPI or reducing JTAPI do not provide satisfactory solutions, because adding to JTAPI increases the need for finding event classes, and reducing JTAPI eliminates the benefit of a standard API that permits portability of applications across platforms.
Accordingly, there is a need for a telephony API for a radio communications device and associated classes that occupy a minimum of memory and support features that are unique to radio telephony.